.TH std::linear_congruential_engine 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::linear_congruential_engine \- std::linear_congruential_engine

.SH Synopsis
   Defined in header <random>
   template<

       class UIntType,
       UIntType a,                      \fI(since C++11)\fP
       UIntType c,
       UIntType m

   > class linear_congruential_engine;

   linear_congruential_engine is a random number engine based on Linear congruential
   generator (LCG).

.SH Template parameters

              The result type generated by the generator. The effect is undefined if
   UIntType - this is not one of unsigned short, unsigned int, unsigned long, or
              unsigned long long.
   a        - the multiplier term
   c        - the increment term
   m        - the modulus term

   When m is not zero, if a >= m or c >= m is true, the program is ill-formed.

   Generator properties

   The size of the states of linear_congruential_engine is 1, each of them consists of
   a single integer.

   The actual modulus \\(m_0\\)m
   0 is defined as follows:

     * If m is not zero, \\(m_0\\)m
       0 is m.
     * If m is zero, \\(m_0\\)m
       0 is the value of std::numeric_limits<result_type>::max() plus 1 (which means
       \\(m_0\\)m
       0 need not be representable as result_type).

   The transition algorithm of linear_congruential_engine is \\(TA(x_i) = (a \\cdot x_i +
   c)\\mod m_0\\)TA(x
   i) = (a·x
   i+c) mod m
   0.

   The generation algorithm of linear_congruential_engine is \\(GA(x_i) = (a \\cdot x_i +
   c)\\mod m_0\\)GA(x
   i) = (a·x
   i+c) mod m
   0.

   The pseudo-random number generated with the current state is also the successor
   state.

   Predefined specializations

   The following specializations define the random number engine with two commonly used
   parameter sets:

   Defined in header <random>
   Type         Definition
                std::linear_congruential_engine<std::uint_fast32_t,
   minstd_rand0                                 16807, 0, 2147483647>
   \fI(C++11)\fP
                Discovered in 1969 by Lewis, Goodman and Miller, adopted as "Minimal
                standard" in 1988 by Park and Miller
                std::linear_congruential_engine<std::uint_fast32_t,
   minstd_rand                                  48271, 0, 2147483647>
   \fI(C++11)\fP      Newer "Minimum standard", recommended by Park, Miller, and Stockmeyer
                in 1993

   Nested types

   Type        Definition
   result_type UIntType

   Data members

   constexpr UIntType multiplier   a
   \fB[static]\fP                        \fI(public static member constant)\fP
   constexpr UIntType increment    c
   \fB[static]\fP                        \fI(public static member constant)\fP
   constexpr UIntType modulus      m
   \fB[static]\fP                        \fI(public static member constant)\fP
   constexpr UIntType default_seed 1u
   \fB[static]\fP                        \fI(public static member constant)\fP

.SH Member functions

.SH Construction and Seeding
   constructor      constructs the engine
   \fI(C++11)\fP          \fI(public member function)\fP
   seed             sets the current state of the engine
   \fI(C++11)\fP          \fI(public member function)\fP
.SH Generation
   operator()       advances the engine's state and returns the generated value
   \fI(C++11)\fP          \fI(public member function)\fP
   discard          advances the engine's state by a specified amount
   \fI(C++11)\fP          \fI(public member function)\fP
.SH Characteristics
   min              gets the smallest possible value in the output range
   \fB[static]\fP \fI(C++11)\fP \fI(public static member function)\fP
   max              gets the largest possible value in the output range
   \fB[static]\fP \fI(C++11)\fP \fI(public static member function)\fP

.SH Non-member functions

   operator==                compares the internal states of two pseudo-random number
   operator!=                engines
   \fI(C++11)\fP                   \fI(function)\fP
   \fI(C++11)\fP(removed in C++20)
   operator<<                performs stream input and output on pseudo-random number
   operator>>                engine
   \fI(C++11)\fP                   \fI(function template)\fP

.SH Example

    This section is incomplete
    Reason: no example

.SH Category:
     * Todo no example
